# 考点：字符串
"""
题目描述
IGMP协议中，有一个字段称作最大响应时间 (Max Response Time) ，HOST收到查询报文，解折出 MaxResponsetime 字段后，需要在 (0，MaxResponseTime] 时间 (s) 内选取随机时间回应一个响应报文，如果在随机时间内收到一个新的查询报文，则会根据两者时间的大小，选取小的一方刷新回应时间。
最大响应时间有如下计算方式：

当 Max Resp Code < 128, Max Resp Time = Max Resp Code；
当 Max Resp Code ≥ 128, Max Resp Time = (mant | 0x10) << (exp + 3)；
![alt](https://uploadfiles.nowcoder.com/images/20241113/662536501_1731502621433/4A47A0DB6E60853DEDFCFDF08A5CA249)
注: exp最大响应时间的高5~7位: mant 为最大响应时间的低4位。

其中接收到的MaxRespCode 最大值为 255，以上出现所有字段均为无符号数。

现在我们认为 HOST收到查询报文时，选取的随机时间必定为最大值，现给出 HOST 收到查询报文个数 C，HOST 收到该报文的时间T，以及查询报文的最大响应时间字段值 M，请计算出HOST 发送响应报文的时间。

输入描述
第一行为查询报文个数 C，后续每行分别为 HOST 收到报文时间 T，及最大响应时间M，以空格分割。

输出描述
HOST 发送响应报文的时间。

备注
用例确定只会发送一个响应报文， 不存在计时结束后依然收到查询报文的情况。

示例1
输入
    3
    0 20
    1 10
    8 20
    输出

    11
说明

收到3个报文，
第0秒收到第1个报文，响应时间为20秒，则要到0+20=20秒响应；
第1秒收到第2个报文，响应时间为10秒，则要到1+10=11秒响应，与上面的报文的响应时间比较获得响应时间最小为11秒；

第8秒收到第3个报文，响应时间为20秒，则要到8+20=28秒响应，与第上面的报文的响应时间比较获得响应时间最小为11秒；

最终得到最小响应报文时间为11秒

示例2
输入
    2
    0 255
    200 60
    输出

    260
说明

收到2个报文，
第0秒收到第1个报文，响应时间为255秒，则要到(15 | 0x10) << (7 + 3)= 31744秒响应; (mant = 15，exp =7)

第200秒收到第2个报文，响应时间为60秒，则要到200+60-260秒响应，与第上面的报文的响应时间比较获得响应时间最小为260秒:

最终得到最小响应报文时间为260秒

作者：左雀斑
链接：https://www.nowcoder.com/discuss/686316153387454464?sourceSSR=search
来源：牛客网
"""



# x = int(input())
# my_dict = {}
#
# resT = 0
# resLi = []
#
# for _ in range(x):
#     a, b = map(int, input().split())
#     my_dict[a] = b
#
# for k, v in my_dict.items():
#     if v < 128:
#         resT = k + v
#     if v >= 128:
#         mant = v & 0x0F  # 低4位: bits 0-3
#         exp = (v >> 5) & 0x07  # 高3位: bits 5-7
#         resT =  (mant | 0x10) << (exp + 3)
#     resLi.append(resT)
#
# minVal = min(resLi)
# print(minVal)

# ❌ 问题：你用字典 my_dict 存储 (T, M)，但字典的 key 是 T（接收时间），而 T 可能重复！
# 题目中并没有说接收时间 T 是唯一的。
# 如果两个报文在同一个时间 T 到达，后面的会覆盖前面的！


# AI纠正：

x = int(input())
min_response = float('inf')  # 初始化为无穷大

for _ in range(x):
    T, M = map(int, input().split())

    if M < 128:
        max_resp = M
    else:
        mant = M & 0x0F
        exp = (M >> 5) & 0x07
        max_resp = (mant | 0x10) << (exp + 3)

    planned_time = T + max_resp
    if planned_time < min_response:
        min_response = planned_time

print(min_response)


# AI书写：

# import sys
#
#
# def main():
#     data = sys.stdin.read().splitlines()
#     if not data:
#         return
#
#     c = int(data[0])
#     min_time = float('inf')
#
#     for i in range(1, c + 1):
#         parts = data[i].split()
#         T = int(parts[0])
#         M = int(parts[1])
#
#         if M < 128:
#             max_resp = M
#         else:
#             exp = (M >> 5) & 0x07  # bits 5-7
#             mant = M & 0x0F  # bits 0-3
#             max_resp = (mant | 0x10) << (exp + 3)
#
#         planned = T + max_resp
#         if planned < min_time:
#             min_time = planned
#
#     print(min_time)
#
#
# if __name__ == "__main__":
#     main()


# 牛客网：

# import sys
#
# numQueries = int(input()) # 查询报文个数
# arrivalTime = [0] * numQueries # HOST收到报文时间
# maxRespCode = [0] * numQueries # 最大响应时间字段值
#
# for i in range(numQueries):
#     arrivalTime[i], maxRespCode[i] = map(int, input().split())
#
# minResponseTime = sys.maxsize # HOST发送响应报文的时间
# for i in range(numQueries):
#     maxRespTime = 0
#     if maxRespCode[i] < 128: # 当MaxRespCode < 128 ,MaxRespTime = MaxRespCode
#         maxRespTime = maxRespCode[i]
#     else: # 当MaxRespCode >= 128 ,MaxRespTime = (mant | 0x10) << (exp + 3)
#         exp = (maxRespCode[i] & 0x70) >> 4 # exp 最大响应时间的 高5~7位
#         mant = maxRespCode[i] & 0x0F # mant 为最大响应时间的 低4位
#         maxRespTime = (mant | 0x10) << (exp + 3)
#     responseTime = arrivalTime[i] + maxRespTime # HOST发送响应报文的时间
#     minResponseTime = min(minResponseTime, responseTime) # 更新最小的 HOST发送响应报文的时间
#
# print(minResponseTime)
